【BUUCTF】MISC(第3页wp)

本文最后更新于：2023年8月25日 下午

[TOC]

[SUCTF2018]single dog

我们使用foremost分离jpg图片

打开txt文件：

发现是js颜文字加密（AAEncode） ，使用 AAEncode解密

我吃三明治

我们在图片中发现了一串类似base32加密的串：

使用base32网站解密

sqltest

我们使用 wireshark 打开 pcapng 文件，然后导出http对象：

我们发现有很多 sql注入的测试，我们可以通过这些sql注入来判断flag

我们一个一个判断，得出flag的ascii值：

102 108 97 103 123 52 55 101 100 98 56 51 48 48 101 100 53 102 57 98 50 56 102 99 53 52 98 48 100 48 57 101 99 100 101 102 55 125

我们将其转化为字符：

[SWPU2019]你有没有好好看网课?

我们使用 ARCHPR 爆破密码：

打开文件夹：

我们打开 word文档：

5.20 7.11这个猜测是视频的秒数，我们使用 Kinovea 打开视频（可以一帧一帧的看视频）：

在 5.66秒处发现提示

敲击码：

1
..... ../... ./... ./... ../
JBOSS-CLI

1
2
3
..... ../... ./... ./... ../	通过斜杠分为不同的组
 5  2 / 3 1 / 3 1/ 3 2/
  W      L    L    M
AWK

在 7.36 秒 发现第二段信息：

base64解密，我们可以使用 php -r 在命令行执行php代码

两段密码拼接一下得到 flag1 压缩包密码。

010Editor 打开图片得到flag

[ACTF新生赛2020]NTFS数据流

NTFS交换数据流（alternate data streams，简称ADS）是NTFS磁盘格式的一个特性，在NTFS文件系统下，每个文件都可以存在多个数据流，就是说除了主文件流之外还可以有许多非主文件流寄宿在主文件流中。它使用资源派生来维持与文件相关的信息，虽然我们无法看到数据流文件，但是它却是真实存在于我们的系统中的。创建一个数据交换流文件的方法很简单，命令为“宿主文件：准备与宿主文件关联的数据流文件”。————百度百科

我们打开文件夹，发现一个大小不一样的文件：

注意：这里解压的时候使用Win RAR解压，涉及NTFS流的都需要Win RAR解压

然后我们使用工具 ：NtfsStreamsEditor 扫描txt文件：

发现 293.txt 文件中 还存在一个flag.txt 文件，直接打开获得flag。

或者，使用命令 notepad 打开：

john-in-the-middle

使用 wireshark 带出http对象：

使用 stegsolve分析，得到flag

[ACTF新生赛2020]swp

我们导出 http 对象，发现一个 secret.zip 压缩包

然后发现是 zip 伪加密，我们可以使用工具：ZipCenOp 修复：

搜索 ctf 发现 flag：

喵喵喵

首先我们使用 Stegsolve 打开：

发现图片 Blue 0通道 有问题

我们使用 Data Extract ，LSB隐写，我们使用 BGR 的位平面顺序:

保存为 png 图片，一张不全的二维码，我们改一下高度：

扫码获得一个链接，下载得到一个txt文件：

说flag不在这里，但是肯定在这里，只是我们看不到而已看，我们想到了 NTFS数据流隐写 ，我们使用工具：NtfsStreamsEditor2

发现隐藏了一个 flag.pyc 文件，我们导出该文件。

pyc文件就是由Python文件经过编译后所生成的文件，py文件编译成pyc文件后加载速度更快而且提高了代码的安全性。

我们知道 pyc 文件是 python经过编译后的文件，我们可以使用 反编译

获得 py文件，我们只需要将代码反过来，自己写一个解码函数，将其解码即可：

1
2
3
4
5
6
7
8
9
10
11
def decode(ciphertext):
    ciphertext = ciphertext[::-1]
    for i in range(len(ciphertext)):
        ciphertext[i] = int(ciphertext[i])
        if i % 2 == 0:
            ciphertext[i] = chr(ciphertext[i] - 10) 
        else:
            ciphertext[i] = chr(ciphertext[i] + 10) 

        s = chr(ord(ciphertext[i]) ^ i)
        print(s,end="")
PYTHON

[GXYCTF2019]SXMgdGhpcyBiYXNlPw==

打开txt文件，发现很多base64编码

我们怀疑这可能是base64隐写，我们使用脚本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

def get_base64_diff_value(s1, s2):
    base64chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
    res = 0
    for i in xrange(len(s2)):
        if s1[i] != s2[i]:
            return abs(base64chars.index(s1[i]) - base64chars.index(s2[i]))
    return res


def solve_stego():
    with open('C://Users/LIKE/Desktop/base64.txt', 'rb') as f:
        file_lines = f.readlines()
        bin_str = ''
        for line in file_lines:
            steg_line = line.replace('\n', '')
            norm_line = line.replace('\n', '').decode('base64').encode('base64').replace('\n', '')
            diff = get_base64_diff_value(steg_line, norm_line)
            print diff
            pads_num = steg_line.count('=')
            if diff:
                bin_str += bin(diff)[2:].zfill(pads_num * 2)
            else:
                bin_str += '0' * pads_num * 2
            print goflag(bin_str)


def goflag(bin_str):
    res_str = ''
    for i in xrange(0, len(bin_str), 8):
        res_str += chr(int(bin_str[i:i + 8], 2))
    return res_str


if __name__ == '__main__':
    solve_stego()
PYTHON

解密得到flag：

间谍启示录

在城际公路的小道上，罪犯G正在被警方追赶。警官X眼看他正要逃脱，于是不得已开枪击中了罪犯G。罪犯G情急之下将一个物体抛到了前方湍急的河流中，便头一歪突然倒地。警官X接近一看，目标服毒身亡。数分钟后，警方找到了罪犯遗失物体，是一个U盘，可惜警方只来得及复制镜像，U盘便报废了。警方现在拜托你在这个镜像中找到罪犯似乎想隐藏的秘密。 注意：得到的 flag 请包上 flag{} 提交

下载得到一个 iso 文件，我们使用foremost分离，发现一个压缩包：

双击运行flag.exe，获得一个txt文件，得到flag：

[UTCTF2020]docx

下载后获得一个 word文档，我们将其后缀改为 zip 解压：

然后我们在： word/media 文件夹中发现flag

Mysterious

自从报名了CTF竞赛后，小明就辗转于各大论坛，但是对于逆向题目仍是一知半解。有一天，一个论坛老鸟给小明发了一个神秘的盒子，里面有开启逆向思维的秘密。小明如获至宝，三天三夜，终于解答出来了，聪明的你能搞定这个神秘盒子么？ 注意：得到的 flag 请包上 flag{} 提交

下载后获得一个 exe 文件：

使用记事本打开：

PE...L... 说明是32位。

或者linux使用file命令：

此处是32位，所以我们使用逆向工具 :ida打开

Shift+F12 查看字符串：

发现 well_done 可疑，我们点进去：

疑似flag的字符串，我们找到这个地址 sub_401090 ，点击后，按 F5 进行反汇编：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
if ( a3 == 1000 )
    {
      GetDlgItemTextA(hWnd, 1002, String, 260);
      strlen(String);
      if ( strlen(String) > 6 )
        ExitProcess(0);
      v4 = atoi(String);
      Value = v4 + 1;
      if ( v4 == 122 && String[3] == 120 && String[5] == 122 && String[4] == 121 )
      {
        strcpy(Text, "flag");
        memset(&Text[5], 0, 0xFCu);
        v8 = 0;
        v9 = 0;
        _itoa(Value, Source, 10);
        strcat(Text, "{");
        strcat(Text, Source);
        strcat(Text, "_");
        strcat(Text, "Buff3r_0v3rf|0w");
        strcat(Text, "}");
        MessageBoxA(0, Text, "well done", 0);
      }
      SetTimer(hWnd, 1u, 0x3E8u, TimerFunc);
    }
ARDUINO

根据分析 我们输入 122xyz 可以获得flag：

弱口令

老菜鸡，伤了神，别灰心，莫放弃，试试弱口令 注意：得到的 flag 请包上 flag{} 提交

下载后得到zip压缩包，在注释中藏有信息。

我们把它复制到 sublime 中：

这时莫斯电码，我们把空格看成 . tab键看成 - 

1
.... . .-.. .-.. ----- ..-. --- .-. ..- --
JBOSS-CLI

摩斯电码解密

使用该密码将压缩包进行解密，得到一张图片：

然后这里的考点是 弱口令LSB隐写，我们使用工具 ： cloacked-pixel

这个工具要安装好多模块，容易报错..

由于是弱口令，我们猜测密码为 123456

flag.txt文件包含flag

[RoarCTF2019]黄金6年

下载mp4文件，我们使用 Kinovea 打开：

发现有几个二维码

Kinovea没有key4，我们可以使用potplayer : F键前进一帧，D键倒退一帧，空格键正常播放

1
key: iwantplayctf
AVRASM

010Editor 打开MP4：

base64解码

另存为 rar，使用key解压，得到flag

小易的U盘

小易的U盘中了一个奇怪的病毒，电脑中莫名其妙会多出来东西。小易重装了系统，把U盘送到了攻防实验室，希望借各位的知识分析出里面有啥。请大家加油噢，不过他特别关照，千万别乱点他U盘中的资料，那是机密。 注意：得到的 flag 请包上 flag{} 提交

我们使用 foremost 分离 iso文件，然后在 autorun.inf 文件中发现：

flag与 autoflag - 副本 (32).exe 文件有关，我们可以使用 ida 打开exe文件获得flag，

或者使用 strings命令获得flag：strings 32.exe | grep "flag"

[WUSTCTF2020]alison_likes_jojo

首先下载获得两个jpg图片，然后使用foremost分离其中一张图片，得到一个加密压缩包：

使用 ARCHPR 爆破 ，得到密码：888866

打开获得base64加密字符串，三次解码：killerqueen

由于是 jpg 图片隐写，所以我们尝试几次 ：那些图片隐写中的神操作之JPG

我们发现这里是 outguess 隐写，我们使用key解密：

1
outguess -k "killerqueen" -r "jljy.jpg" flag.txt
NGINX

获得flag

[安洵杯 2019]吹着贝斯扫二维码

下载后得到一个文件夹，里面有很多文件，我们使用 010Editor打开后发现都是jpg图片，我们使用脚本改后缀：

1
2
3
4
5
6
7
import os

path = r'C:\Users\LIKE\Desktop\dir'  
for i in os.listdir(path):  # 路径最好用绝对路径，不会出错
    oldname = os.path.join(path, i)
    newname = os.path.join(path, i + '.jpg')
    os.rename(oldname, newname)
PYTHON

我们发现都是二维码，我们需要拼图，

每一个图片最后都有顺序，我们按照这个顺序使用ps进行拼图：

如下：

扫码得到：

（这个编码应该从右往左读）

我们打开zip文件：显然这是base32编码

base32解码： 3A715D3E574E36326F733C5E625D213B2C62652E3D6E3B7640392F3137274038624148

然后转为 16进制字符串： :q]>WN62os<^b]!;,be.=n;v@9/17'@8bAH

然后这里提示一个 13编码，这里为 rot13，我们解密：

:d]>JA62bf<^o]!;,or.=a;i@9/17'@8oNU

然后base85解密：

PCtvdWU4VFJnQUByYy4mK1lraTA=

base64解密： <+oue8TRgA@rc.&+Yki0

最后base85解密：ThisIsSecret!233

解压zip获得flag

[WUSTCTF2020]爬

下载一个文件，使用 010Editor 打开，发现是一个pdf文件，改后缀为pdf，然后打开：

说flag被遮住了，我们使用 pdf编辑器删除上面的图片，里面还有一张图片：

发现是16进制，我们将其转化为字符串即可得到flag。

flag{th1s_1s_@_pdf_and_y0u_can_use_phot0sh0p}

zip

我们首先下载，然后得到一个文件夹里面有很多 zip 文件，全被加密了：

但是我们发现每一个压缩包里的txt文件内容很小，都只有 4字节，于是我们可以使用crc32值进行

crc32 4字节爆破

我们使用脚本爆破（也可以使用github上的脚本）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
# python3
import zipfile
import string
import binascii


def CrackCrc(crc):
    for i in dic:
        for j in dic:
            for k in dic:
                for h in dic:
                    s = i + j + k + h
                    if crc == (binascii.crc32(s.encode())):
                        f.write(s)
                        return


def CrackZip():
    for i in range(0, 68):
        file = r"C://Users/LIKE/Desktop/dir/" + 'out' + str(i) + '.zip'
        crc = zipfile.ZipFile(file, 'r').getinfo('data.txt').CRC # 获得crc值
        CrackCrc(crc)
        print('\r' + "loading：{:%}".format(float((i + 1) / 68)), end='')


dic = string.ascii_letters + string.digits + '+/='
f = open('out.txt', 'w')
print("\nCRC32begin")
CrackZip()
print("CRC32finished")
f.close()
PYTHON

获得一串base64编码，我们解密一下：

这16进制结尾应该是rar文件 ，缺少文件头 52 61 72 21 1A 07 00 ，我们补上，打开rar文件：

从娃娃抓起

题目描述：伟人的一句话，标志着一个时代的开始。那句熟悉的话，改变了许多人的一生，为中国三十年来计算机产业发展铺垫了道路。两种不同的汉字编码分别代表了汉字信息化道路上的两座伟大里程碑。请将你得到的话转为md5提交，md5统一为32位小写。

打开txt文件，第2行应该是五笔输入法，第一行是 中文电码。

中文电码解密

在线五笔输入

人工智能也要从娃娃抓起

md5加密

[GUET-CTF2019]zips

首先下载得到 zip压缩包 222.zip ，发现需要密码，但是我们不知道，我们只能使用 ARCHPR 爆破，获得密码，解压缩得到 111.zip

发现是伪加密，我们可以使用工具 ZipCenOp 修复伪加密

1
java -jar ZipCenOp.jar r 111.zip
MIPSASM

打开，发现 setup.sh 文件：

1
2
3
#!/bin/bash
#
zip -e --password=`python -c "print(__import__('time').time())"` flag.zip flag
SH

这里使用了 时间戳当作压缩包密码进行解压，但是我们不知道时间是多少。

我们先查看一下当前的时间戳（注意是python2）：

我们通过文件修改日期推测 时间戳是 15…..

我们可以使用掩码爆破 ，进行解压：

获得时间戳，我们进行解压，得到flag

[DDCTF2018](╯°□°）╯︵ ┻━┻

打开txt文件：

1
d4e8e1f4a0f7e1f3a0e6e1f3f4a1a0d4e8e5a0e6ece1e7a0e9f3baa0c4c4c3d4c6fbb9b2b2e1e2b9b9b7b4e1b4b7e3e4b3b2b2e3e6b4b3e2b5b0b6b1b0e6e1e5e1b5fd
LLVM

长度134的字16进制符串，每两位进行截取

1
['d4', 'e8', 'e1', 'f4', 'a0', 'f7', 'e1', 'f3', 'a0', 'e6', 'e1', 'f3', 'f4', 'a1', 'a0', 'd4', 'e8', 'e5', 'a0', 'e6', 'ec', 'e1', 'e7', 'a0', 'e9', 'f3', 'ba', 'a0', 'c4', 'c4', 'c3', 'd4', 'c6', 'fb', 'b9', 'b2', 'b2', 'e1', 'e2', 'b9', 'b9', 'b7', 'b4', 'e1', 'b4', 'b7', 'e3', 'e4', 'b3', 'b2', 'b2', 'e3', 'e6', 'b4', 'b3', 'e2', 'b5', 'b0', 'b6', 'b1', 'b0', 'e6', 'e1', 'e5', 'e1', 'b5', 'fd']
SCHEME

转为10进制：

1
[212, 232, 225, 244, 160, 247, 225, 243, 160, 230, 225, 243, 244, 161, 160, 212, 232, 229, 160, 230, 236, 225, 231, 160, 233, 243, 186, 160, 196, 196, 195, 212, 198, 251, 185, 178, 178, 225, 226, 185, 185, 183, 180, 225, 180, 183, 227, 228, 179, 178, 178, 227, 230, 180, 179, 226, 181, 176, 182, 177, 176, 230, 225, 229, 225, 181, 253]
ACCESSLOG

将大于 128的数字减128得到ascii码：

1
[84, 104, 97, 116, 32, 119, 97, 115, 32, 102, 97, 115, 116, 33, 32, 84, 104, 101, 32, 102, 108, 97, 103, 32, 105, 115, 58, 32, 68, 68, 67, 84, 70, 123, 57, 50, 50, 97, 98, 57, 57, 55, 52, 97, 52, 55, 99, 100, 51, 50, 50, 99, 102, 52, 51, 98, 53, 48, 54, 49, 48, 102, 97, 101, 97, 53, 125]
ACCESSLOG

全部转为字符：

1
That was fast! The flag is: DDCTF{922ab9974a47cd322cf43b50610faea5}
ACTIONSCRIPT

脚本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# -*- coding:utf-8 -*-
def hex_str(str):#对字符串进行切片操作，每两位截取
    hex_str_list=[]
    for i in range(0,len(str)-1,2):
        hex_str=str[i:i+2]
        hex_str_list.append(hex_str)
    print("hex列表：%s\n"%hex_str_list)
    hex_to_str(hex_str_list)

def hex_to_str(hex_str_list):
    int_list=[]
    dec_list=[]
    flag=''
    for i in range(0,len(hex_str_list)):#把16进制转化为10进制
        int_str=int('0x%s'%hex_str_list[i],16)
        int_list.append(int_str)
        dec_list.append(int_str-128)#-128得到正确的ascii码
    for i in range(0,len(dec_list)):#ascii码转化为字符串
        flag += chr(dec_list[i])
    print("转化为十进制int列表：%s\n"%int_list)
    print("-128得到ASCII十进制dec列表：%s\n"%dec_list)
    print('最终答案：%s'%flag)

if __name__=='__main__':
    str='d4e8e1f4a0f7e1f3a0e6e1f3f4a1a0d4e8e5a0e6ece1e7a0e9f3baa0c4c4c3d4c6fbb9b2b2e1e2b9b9b7b4e1b4b7e3e4b3b2b2e3e6b4b3e2b5b0b6b1b0e6e1e5e1b5fd'
    print("字符串长度：%s"%len(str))
    hex_str(str)
PYTHON

[WUSTCTF2020]girlfriend

下载获得一个 wav音频文件，播放一下，听起来像打电话，于是我们可以使用工具 dtmf2num，进行拨号音识别：

1
999*666*88*2*777*33*6*999*4*444*777*555*333*777*444*33*66*3*7777
APACHE

看这一串数字，应该是手机键盘加密。

999就是指按三下数字9得到的字母也就是y，以此类推，数字对应手机的每个键位，几个数字代表按几下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
999     --->   y
666     --->   o
88      --->   u
2       --->   a
777     --->   r
33      --->   e
6       --->   m
999     --->   y
4       --->   g
4444    --->   i
777     --->   r
555     --->   l
333     --->   f
777     --->   r
444     --->   i
33      --->   e
66      --->   n
3       --->   d
7777    --->   s

youaremygirlfriends
ADA

[MRCTF2020]千层套路

这一题是一个 zip无线套娃题

脚本：

1
2
3
4
5
6
7
8
9
10
11
12
13
import zipfile

filepath = "0573.zip"

while zipfile.is_zipfile("zip/" + filepath): # 当文件是zip文件时
    pwd = filepath.split(".")[0] #获得解压密码
    file = zipfile.ZipFile("zip/" + filepath) # 创建一个ZipFile对象，表示一个zip文件
    filepath = file.namelist().pop() # namelist()获取zip文档内所有文件的名称列表
    file.extract(filepath, r"D:\Applications\CTF\phpstudy_pro\WWW\scripts_py\BUUCTF\zip", pwd=pwd.encode('utf-8'))
    file.close()
    print(filepath)

print("解压成功！")
PYTHON

[XMAN2018排位赛]通行证

首先base64解密：

得到： kanbbrgghjl{zb____}vtlaln ，这个可能是栅栏密码。

注意：此处是栅栏加密，不是解密 栅栏密码

每组字数为7。

然后发现应该凯撒解密，得到flag

1
xman{oyay_now_you_get_it}
DUST

百里挑一

下载得到一个 pcapng文件，我们使用 wireshark导出 http对象，发现一堆图片。

然后我们使用 exiftool 工具 ，查看所有图片的 详细信息，并且过滤出带有 { 的字段

1
exiftool * | grep '{'
GRADLE

我们得到了一半的 flag

我们我们在 wireshark 中过滤，查找字符串 Exif：

1
tcp contains "Exif"
APPLESCRIPT

找到另一半flag：

[SUCTF2018]followme

我们使用 wireshark 导出 http对象：

一大串登录的东西

我们使用 linux grep 命令

grep -r "CTF" 查找整个目录下的字符串，得到flag

[UTCTF2020]file header

使用 010Editor 改一下文件头即可

[MRCTF2020]CyberPunk

下载后获得一个exe程序，打开：

提示说，只要我们时间是 2020.9.17 就能得到flag。

我们只需要修改计算机系统时间为 2020.9.17 即可

[安洵杯 2019]Attack

首先使用 foremost 分离 pcap 文件，得到一个压缩包：

然后查看wp后，发现这个需要获取到管理员的密码去解压。

我们这里需要用到一个工具： mimikatz

mimikatz 在内网渗透中是个很有用的工具。mimikatz可以在内存中爬取到明文密码

下载：
https://github.com/gentilkiwi/mimikatz/releases/

然后我们可以使用 wireshark 去导出 lsass.dmp 内存镜像

关于lsass

lsass是windows系统的一个进程，用于本地安全和登陆策略。

mimikatz可以从 lsass.exe 里获取windows处于active状态账号明文密码。

本题的lsass.dmp就是内存运行的镜像，也可以提取到账户密码

如何使用？我们可以先将 lsass.dmp 复制到mimikatz目录下

然后右键管理员运行 mimikatz.exe：（不用会报错）

输入：

1
2
3
4
5
6
//提升权限
privilege::debug
//载入dmp文件
sekurlsa::minidump lsass.dmp
//读取登陆密码
sekurlsa::logonpasswords full
LASSO

得到：

密码： W3lc0meToD0g3

解压zip得到flag

[SUCTF 2019]Game

下载后得到一个游戏源码和一张图片。

在游戏源码 index.html 中，我们发现了一个fake flag：

这是base32编码，我们解码： suctf{hAHaha_Fak3_F1ag} 一个假的flag

然后我们去分析图片：

我们发现了 LSB隐写：

这一串看着像 base64，但是我们解码一下： Salted__³4yƒíYRÁ|ÜTVK»¤&Ñ:?)뇃ËÊkU

Salted开头，一个是 AES、DES等编码，经过测试，发现是 3DES 即：TripleDES

密钥就是：suctf{hAHaha_Fak3_F1ag}，

解密得到flag：https://www.sojson.com/encrypt_triple_des.html

USB

Do your konw usb?? 注意：得到的 flag 请包上 flag{} 提交

下载后得到一个 rar压缩包 和 key.ftm 文件

使用 010Editor 打开 key.ftm ：

我们发现其中隐藏着 zip压缩包，我们使用 foremost 分离得到 流量包文件：

观察可知，这是USB流量包分析 ，这一题是 USB键盘流量分析.

USB流量指的是USB设备接口的流量，攻击者能够通过监听usb接口流量获取键盘敲击键、鼠标移动与点击、存储设备的铭文传输通信、USB无线网卡网络传输内容等等。在CTF中，USB流量分析主要以键盘和鼠标流量为主。

键盘流量

USB协议数据部分在Leftover Capture Data域中，数据长度为八个字节。其中键盘击键信息集中在第三个字节中。

如图，发现击键信息为0x06，即对应的按键为C
键位映射关系参考：《USB键盘协议中键码》中的HID Usage ID

我们可以使用 linux 的 tshark命令 把usb流量包key.pcap中 capdata 读取出来：

1
2
tshark -r key.pcap -T fields -e usb.capdata > usbdata.txt
tshark -r key.pcap -T fields -e usb.capdata | sed '/^\s*$/d' > usbdata.txt #提取并去除空行
SH

我们查看一下txt文件：

提取出来的数据可能会带冒号，也可能不带（有可能和wireshark的版本相关），但是一般的脚本都会按照有冒号的数据来识别

有冒号时提取数据的[6:8]
无冒号时数据在[4:6]

可以用脚本来加上冒号：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# -*- coding = utf-8 -*-
# @Time : 2023/1/30 13:59
# @Author : Leekos
# @File : USB_tshark_键盘capdata添加冒号.py
# @Software : PyCharm
f = open('C://Users/LIKE/Desktop/data.txt', 'r')
fi = open('C://Users/LIKE/Desktop/out.txt', 'w')
while 1:
    a = f.readline().strip()
    if a:
        if len(a) == 16:  # 鼠标流量的话len改为8
            out = ''
            for i in range(0, len(a), 2):
                if i + 2 != len(a):
                    out += a[i] + a[i + 1] + ":"
                else:
                    out += a[i] + a[i + 1]
            fi.write(out)
            fi.write('\n')
    else:
        break

fi.close()
PYTHON

如图：

此时对应的第三字节，也就是**[6:8]**就代表了击键信息

提取出键盘流量后需要用脚本还原数据对应的信息。同时找到两个还原信息的脚本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# python2
mappings = { 0x04:"A",  0x05:"B",  0x06:"C", 0x07:"D", 0x08:"E", 0x09:"F", 0x0A:"G",  0x0B:"H", 0x0C:"I",  0x0D:"J", 0x0E:"K", 0x0F:"L", 0x10:"M", 0x11:"N",0x12:"O",  0x13:"P", 0x14:"Q", 0x15:"R", 0x16:"S", 0x17:"T", 0x18:"U",0x19:"V", 0x1A:"W", 0x1B:"X", 0x1C:"Y", 0x1D:"Z", 0x1E:"1", 0x1F:"2", 0x20:"3", 0x21:"4", 0x22:"5",  0x23:"6", 0x24:"7", 0x25:"8", 0x26:"9", 0x27:"0", 0x28:"\n", 0x2a:"[DEL]",  0X2B:"    ", 0x2C:" ",  0x2D:"-", 0x2E:"=", 0x2F:"[",  0x30:"]",  0x31:"\\", 0x32:"~", 0x33:";",  0x34:"'", 0x36:",",  0x37:"." }

nums = []
keys = open('C://Users/LIKE/Desktop/out.txt')
for line in keys:
    if line[0]!='0' or line[1]!='0' or line[3]!='0' or line[4]!='0' or line[9]!='0' or line[10]!='0' or line[12]!='0' or line[13]!='0' or line[15]!='0' or line[16]!='0' or line[18]!='0' or line[19]!='0' or line[21]!='0' or line[22]!='0':
         continue
    nums.append(int(line[6:8],16))

keys.close()

output = ""
for n in nums:
    if n == 0 :
        continue
    if n in mappings:
        output += mappings[n]
    else:
        output += '[unknown]'

print 'output :\n' + output
PYTHON

脚本2（两个都可以）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
# python3

normalKeys = {
    "04":"a", "05":"b", "06":"c", "07":"d", "08":"e",
    "09":"f", "0a":"g", "0b":"h", "0c":"i", "0d":"j",
     "0e":"k", "0f":"l", "10":"m", "11":"n", "12":"o",
      "13":"p", "14":"q", "15":"r", "16":"s", "17":"t",
       "18":"u", "19":"v", "1a":"w", "1b":"x", "1c":"y",
        "1d":"z","1e":"1", "1f":"2", "20":"3", "21":"4",
         "22":"5", "23":"6","24":"7","25":"8","26":"9",
         "27":"0","28":"<RET>","29":"<ESC>","2a":"<DEL>", "2b":"\t",
         "2c":"<SPACE>","2d":"-","2e":"=","2f":"[","30":"]","31":"\\",
         "32":"<NON>","33":";","34":"'","35":"<GA>","36":",","37":".",
         "38":"/","39":"<CAP>","3a":"<F1>","3b":"<F2>", "3c":"<F3>","3d":"<F4>",
         "3e":"<F5>","3f":"<F6>","40":"<F7>","41":"<F8>","42":"<F9>","43":"<F10>",
         "44":"<F11>","45":"<F12>"}
shiftKeys = {
    "04":"A", "05":"B", "06":"C", "07":"D", "08":"E",
     "09":"F", "0a":"G", "0b":"H", "0c":"I", "0d":"J",
      "0e":"K", "0f":"L", "10":"M", "11":"N", "12":"O",
       "13":"P", "14":"Q", "15":"R", "16":"S", "17":"T",
        "18":"U", "19":"V", "1a":"W", "1b":"X", "1c":"Y",
         "1d":"Z","1e":"!", "1f":"@", "20":"#", "21":"$",
          "22":"%", "23":"^","24":"&","25":"*","26":"(","27":")",
          "28":"<RET>","29":"<ESC>","2a":"<DEL>", "2b":"\t","2c":"<SPACE>",
          "2d":"_","2e":"+","2f":"{","30":"}","31":"|","32":"<NON>","33":"\"",
          "34":":","35":"<GA>","36":"<","37":">","38":"?","39":"<CAP>","3a":"<F1>",
          "3b":"<F2>", "3c":"<F3>","3d":"<F4>","3e":"<F5>","3f":"<F6>","40":"<F7>",
          "41":"<F8>","42":"<F9>","43":"<F10>","44":"<F11>","45":"<F12>"}
output = []
keys = open('C://Users/LIKE/Desktop/out.txt')
for line in keys:
    try:
        if line[0]!='0' or (line[1]!='0' and line[1]!='2') or line[3]!='0' or line[4]!='0' or line[9]!='0' or line[10]!='0' or line[12]!='0' or line[13]!='0' or line[15]!='0' or line[16]!='0' or line[18]!='0' or line[19]!='0' or line[21]!='0' or line[22]!='0' or line[6:8]=="00":
             continue
        if line[6:8] in normalKeys.keys():
            output += [[normalKeys[line[6:8]]],[shiftKeys[line[6:8]]]][line[1]=='2']
        else:
            output += ['[unknown]']
    except:
        pass

keys.close()

flag=0
print("".join(output))
for i in range(len(output)):
    try:
        a=output.index('<DEL>')
        del output[a]
        del output[a-1]
    except:
        pass

for i in range(len(output)):
    try:
        if output[i]=="<CAP>":
            flag+=1
            output.pop(i)
            if flag==2:
                flag=0
        if flag!=0:
            output[i]=output[i].upper()
    except:
        pass

print ('output :' + "".join(output))
PYTHON

运行脚本：

1
2
输出：
output :key{xinan}
GAUSS

于是我们得到密钥：xinan

参考：USB流量分析

我们也可以使用工具: UsbKeyboardDataHacker

接着我们再分析那一个rar压缩包：

发现文件头损坏，于是查资料进行对照，

将这里改为 74 即可：

我们得到一张 png 图片，使用 stegsolve 在blue 0 通道 发现二维码：

扫码获得：ci{v3erf_0tygidv2_fc0}

可能是栅栏密码，我们解密一下，得到：cyig{ivd3ve2r_ff_c00t}

这个很想凯撒密码，但是不是，

查阅资料得知了一个密码：**维吉尼亚密码**

凯撒密码中，字母表中的每一字母都会作一定的偏移。
当偏移量为3时，A就转换为了D、B转换为了E……因为凯撒密码中所有字母的偏移量是一样的

【维吉尼亚密码】则是由一些偏移量不同的恺撒密码组成

为了生成密码，需要使用表格法。

这一表格包括了26行字母表，每一行都由前一行向左偏移一位得到。具体使用哪一行字母表进行编译是基于密钥进行的，在过程中会不断地变换。

例如，假设明文为：HEETIAN

然后选择某一关键词并重复而得到密钥，如关键词为LAB时，密钥为：LABLABL

对于明文的第一个字母H，对应密钥的第一个字母L，于是使用表格中L行字母表进行加密，得到密文第一个字母S。
类似地，明文第二个字母为E，在表格中使用对应的A行进行加密，得到密文第二个字母E。以此类推，可以得到：

明文：HEETIAN

密钥：LABLABL

密文：SEFEIBY

解密的过程则与加密相反。
例如：根据密钥第一个字母L所对应的L行字母表，发现密文第一个字母S位于H列，因而明文第一个字母为H。
密钥第二个字母A对应A行字母表，而密文第二个字母E位于此行E列，因而明文第二个字母为E。以此类推便可得到明文。

简单地说:【维吉尼亚密码】是由一些偏移量不同的恺撒密码组成，解密需要密钥。

因此我们可以进行解密，但是尝试之后，我们发现需要：先维吉尼亚密码解密，再栅栏解密。

然后栅栏解密：

wp
#【BUUCTF】MISC(第3页wp)
【BUUCTF】MISC(第3页wp)
https://leekosss.github.io/2023/08/24/[BUUCTF]MISC(第3页wp)/
作者
leekos
发布于
2023年8月24日
更新于
2023年8月25日
许可协议